{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=\"+2\">Double Deep Q-Learning & Open AI Gym: Intro</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Open AI Lunar Lander environment "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [OpenAI Gym](https://gym.openai.com/) is a RL platform that provides standardized environments to test and benchmark RL algorithms using Python. It is also possible to extend the platform and register custom environments.\n",
    "\n",
    "The [Lunar Lander](https://gym.openai.com/envs/LunarLander-v2) (LL) environment requires the agent to control its motion in two dimensions, based on a discrete action space and low-dimensional state observations that include position, orientation, and velocity. At each time step, the environment provides an observation of the new state and a positive or negative reward.  Each episode consists of up to 1,000 time steps. The following diagram shows selected frames from a successful landing after 250 episodes by the agent we will train:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../assets/lunar_lander.png\" width=\"700\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More specifically, the agent observes eight aspects of the state, including six continuous and two discrete elements. Based on the observed elements, the agent knows its location, direction, speed of movement, and whether it has (partially) landed. However, it does not know where it should be moving using its available actions or observe the inner state of the environment in the sense of understanding the rules that govern its motion.\n",
    "\n",
    "At each time step, the agent controls its motion using one of four discrete actions. It can do nothing (and continue on its current path), fire its main engine (to reduce downward motion), or steer to the left or right using the respective orientation engines. There are no fuel limitations.\n",
    "\n",
    "The goal is to land the agent between two flags on a landing pad at coordinates (0, 0), but landing outside of the pad is possible. The agent accumulates rewards in the range of 100-140 for moving toward the pad, depending on the exact landing spot. However, moving away from the target negates the reward the agent would have gained by moving toward the pad. Ground contact by each leg adds ten points, and using the main engine costs -0.3 points.\n",
    "\n",
    "An episode terminates if the agent lands or crashes, adding or subtracting 100 points, respectively, or after 1,000 time steps. Solving LL requires achieving a cumulative reward of at least 200 on average over 100 consecutive episodes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q-Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deep Q learning estimates the value of the available actions for a given state using a deep neural network. It was introduced by Deep Mind's [Playing Atari with Deep Reinforcement Learning](https://www.cs.toronto.edu/~vmnih/docs/dqn.pdf) (2013), where RL agents learned to play games solely from pixel input.\n",
    "\n",
    "The Deep Q-Learning algorithm approximates the action-value function q by learning a set of weights  of a multi-layered Deep Q Network (DQN) that maps states to actions so that $$q(s,a,\\theta)\\approx q^*(s,a)$$\n",
    "\n",
    "The algorithm applies gradient descent to a loss function defined as the squared difference between the DQN's estimate of the target \n",
    "$$y_i=\\mathbb{E}[r+\\gamma\\max_{a^\\prime}Q(s^\\prime, a^\\prime; \\theta_{i−1}\\mid s,a)]$$ \n",
    "and its estimate of the action-value of the current state-action pair  to learn the network parameters:\n",
    "\n",
    "$$L_i(\\theta_i)=\\mathbb{E}\\left[\\left(\\overbrace{\\underbrace{y_i}_{\\text{Q Target}}−\\underbrace{Q(s, a; \\theta)}_{\\text{Current Prediction}}}^{\\text{TD Error}}\\right)^2 \\right]$$\n",
    "\n",
    "Both the target and the current estimate depend on the set of weights, underlining the distinction from supervised learning where targets are fixed prior to training. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Several innovations have improved the accuracy and convergence speed of deep Q-Learning, namely:\n",
    "- **Experience replay** stores a history of state, action, reward, and next state transitions and randomly samples mini-batches from this experience to update the network weights at each time step before the agent selects an ε-greedy action. It increases sample efficiency, reduces the autocorrelation of samples, and limits the feedback due to the current weights producing training samples that can lead to local minima or divergence.\n",
    "- **Slowly-changing target network** weakens the feedback loop from the current network parameters on the neural network weight updates. Also invented by by Deep Mind in [Human-level control through deep reinforcement learning](https://web.stanford.edu/class/psych209/Readings/MnihEtAlHassibis15NatureControlDeepRL.pdf) (2015), it use a slowly-changing target network that has the same architecture as the Q-network, but its weights are only updated periodically. The target network generates the predictions of the next state value used to update the Q-Networks estimate of the current state's value.\n",
    "- **Double deep Q-learning** addresses the bias of deep Q-Learning to overestimate action values because it purposely samples the highest action value. This bias can negatively affect the learning process and the resulting policy if it does not apply uniformly , as shown by Hado van Hasselt in [Deep Reinforcement Learning with Double Q-learning](https://arxiv.org/abs/1509.06461) (2015). To decouple the estimation of action values from the selection of actions, Double Deep Q-Learning (DDQN) uses the weights, of one network to select the best action given the next state, and the weights of another network to provide the corresponding action value estimate.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Imports & Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:23.055529Z",
     "start_time": "2020-06-22T16:35:23.053068Z"
    }
   },
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.035596Z",
     "start_time": "2020-06-22T16:35:23.057384Z"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from time import time\n",
    "from pathlib import Path\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import Sequential\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.regularizers import l2\n",
    "\n",
    "# OpenAI Gym\n",
    "import gym\n",
    "from gym import wrappers\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.039813Z",
     "start_time": "2020-06-22T16:35:25.036968Z"
    }
   },
   "outputs": [],
   "source": [
    "sns.set_style('whitegrid', {'axes.grid' : False})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.084121Z",
     "start_time": "2020-06-22T16:35:25.041333Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using GPU\n"
     ]
    }
   ],
   "source": [
    "gpu_devices = tf.config.experimental.list_physical_devices('GPU')\n",
    "if gpu_devices:\n",
    "    print('Using GPU')\n",
    "    tf.config.experimental.set_memory_growth(gpu_devices[0], True)\n",
    "else:\n",
    "    print('Using CPU')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set random seeds to ensure results can be reproduced:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.091173Z",
     "start_time": "2020-06-22T16:35:25.085352Z"
    }
   },
   "outputs": [],
   "source": [
    "np.random.seed(42)\n",
    "tf.random.set_seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Result display helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.104287Z",
     "start_time": "2020-06-22T16:35:25.092398Z"
    }
   },
   "outputs": [],
   "source": [
    "def format_time(t):\n",
    "    m_, s = divmod(t, 60)\n",
    "    h, m = divmod(m_, 60)\n",
    "    return '{:02.0f}:{:02.0f}:{:02.0f}'.format(h, m, s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Enable virtual display to run from docker container"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is only required if you run this on server that does not have a display."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.121872Z",
     "start_time": "2020-06-22T16:35:25.106177Z"
    }
   },
   "outputs": [],
   "source": [
    "# from pyvirtualdisplay import Display\n",
    "# virtual_display = Display(visible=0, size=(1400, 900))\n",
    "# virtual_display.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define DDQN Agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use [TensorFlow](https://www.tensorflow.org/) to create our Double Deep Q-Network ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay Buffer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.131739Z",
     "start_time": "2020-06-22T16:35:25.123559Z"
    }
   },
   "outputs": [],
   "source": [
    "class Memory():\n",
    "    def __init__(self, capacity, state_dims):\n",
    "        self.capacity = capacity\n",
    "        self.idx = 0\n",
    "\n",
    "        self.state_memory = np.zeros(shape=(capacity, state_dims), \n",
    "                                     dtype=np.float32)\n",
    "        self.new_state_memory = np.zeros_like(self.state_memory)\n",
    "\n",
    "        self.action_memory = np.zeros(capacity, dtype=np.int32)\n",
    "        self.reward_memory = np.zeros_like(self.action_memory)\n",
    "        self.done = np.zeros_like(self.action_memory)\n",
    "\n",
    "    def store(self, state, action, reward, next_state, done):\n",
    "        self.state_memory[self.idx, :] = state\n",
    "        self.new_state_memory[self.idx, :] = next_state\n",
    "        self.reward_memory[self.idx] = reward\n",
    "        self.action_memory[self.idx] = action\n",
    "        self.done[self.idx] = 1 - int(done)\n",
    "        self.idx += 1\n",
    "\n",
    "    def sample(self, batch_size):\n",
    "        batch = np.random.choice(self.idx, batch_size, replace=False)\n",
    "\n",
    "        states = self.state_memory[batch]\n",
    "        next_states = self.new_state_memory[batch]\n",
    "        rewards = self.reward_memory[batch]\n",
    "        actions = self.action_memory[batch]\n",
    "        done = self.done[batch]\n",
    "        return states, actions, rewards, next_states, done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agent Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.157998Z",
     "start_time": "2020-06-22T16:35:25.132987Z"
    }
   },
   "outputs": [],
   "source": [
    "class DDQNAgent:\n",
    "    def __init__(self,\n",
    "                 state_dim,\n",
    "                 num_actions,\n",
    "                 gamma,\n",
    "                 epsilon_start,\n",
    "                 epsilon_end,\n",
    "                 epsilon_decay_steps,\n",
    "                 epsilon_exponential_decay,\n",
    "                 learning_rate,\n",
    "                 architecture,\n",
    "                 l2_reg,\n",
    "                 replay_capacity,\n",
    "                 tau,\n",
    "                 batch_size,\n",
    "                 results_dir,\n",
    "                 log_every=10):\n",
    "\n",
    "        self.state_dim = state_dim\n",
    "        self.num_actions = num_actions\n",
    "\n",
    "        self.architecture = architecture\n",
    "        self.l2_reg = l2_reg\n",
    "        self.learning_rate = learning_rate\n",
    "        self.experience = Memory(replay_capacity,\n",
    "                                 state_dim)\n",
    "        self.gamma = gamma\n",
    "        self.tau = tau\n",
    "        self.batch_size = batch_size\n",
    "        self.idx = np.arange(batch_size, dtype=np.int32)\n",
    "\n",
    "        self.online_network = self.build_model()\n",
    "        self.target_network = self.build_model(trainable=False)\n",
    "        self.optimizer = Adam(lr=learning_rate)\n",
    "        self.update_target()\n",
    "\n",
    "        self.epsilon = epsilon_start\n",
    "        self.epsilon_decay_steps = epsilon_decay_steps\n",
    "        self.epsilon_decay = (epsilon_start - epsilon_end) / epsilon_decay_steps\n",
    "        self.epsilon_exponential_decay = epsilon_exponential_decay\n",
    "        self.epsilon_history = []\n",
    "\n",
    "        self.total_steps = self.train_steps = 0\n",
    "        self.episodes = self.episode_length = self.train_episodes = 0\n",
    "        self.steps_per_episode = []\n",
    "        self.episode_reward = 0\n",
    "        self.rewards_history = []\n",
    "\n",
    "        self.results_dir = results_dir\n",
    "        self.experiment = experiment\n",
    "        self.log_every = log_every\n",
    "        \n",
    "        self.summary_writer = (tf.summary\n",
    "                               .create_file_writer(results_dir.as_posix()))\n",
    "        self.start = time()\n",
    "        self.train = True\n",
    "\n",
    "    def build_model(self, trainable=True):\n",
    "        layers = []\n",
    "        for i, units in enumerate(self.architecture, 1):\n",
    "            layers.append(Dense(units=units,\n",
    "                                input_dim=self.state_dim if i == 1 else None,\n",
    "                                activation='relu',\n",
    "                                kernel_regularizer=l2(self.l2_reg),\n",
    "                                trainable=trainable))\n",
    "        layers.append(Dense(units=self.num_actions,\n",
    "                            trainable=trainable))\n",
    "        return Sequential(layers)\n",
    "\n",
    "    def update_target(self):\n",
    "        self.target_network.set_weights(self.online_network.get_weights())\n",
    "\n",
    "    # @tf.function\n",
    "    def epsilon_greedy_policy(self, state):\n",
    "        self.total_steps += 1\n",
    "        if np.random.rand() <= self.epsilon:\n",
    "            return np.random.choice(self.num_actions)\n",
    "        q = self.online_network.predict(state)\n",
    "        return np.argmax(q, axis=1).squeeze()\n",
    "\n",
    "    # @tf.function\n",
    "    def decay_epsilon(self):\n",
    "        if self.train:\n",
    "            if self.episodes < self.epsilon_decay_steps:\n",
    "                self.epsilon -= self.epsilon_decay\n",
    "            else:\n",
    "                self.epsilon *= self.epsilon_exponential_decay\n",
    "\n",
    "    def log_progress(self):\n",
    "        self.rewards_history.append(self.episode_reward)\n",
    "        self.steps_per_episode.append(self.episode_length)\n",
    "\n",
    "        avg_steps_100 = np.mean(self.steps_per_episode[-100:])\n",
    "        avg_steps_10 = np.mean(self.steps_per_episode[-10:])\n",
    "        max_steps_10 = np.max(self.steps_per_episode[-10:])\n",
    "        avg_rewards_100 = np.mean(self.rewards_history[-100:])\n",
    "        avg_rewards_10 = np.mean(self.rewards_history[-10:])\n",
    "        max_rewards_10 = np.max(self.rewards_history[-10:])\n",
    "\n",
    "        with self.summary_writer.as_default():\n",
    "            tf.summary.scalar('Episode Reward', self.episode_reward, step=self.episodes)\n",
    "            tf.summary.scalar('Episode Rewards (MA 100)', avg_rewards_100, step=self.episodes)\n",
    "            tf.summary.scalar('Episode Steps', self.episode_length, step=self.episodes)\n",
    "            tf.summary.scalar('Epsilon', self.epsilon, step=self.episodes)\n",
    "\n",
    "        if self.episodes % self.log_every == 0:\n",
    "            template = '{:03} | {} | Rewards {:4.0f} {:4.0f} {:4.0f} | ' \\\n",
    "                       'Steps: {:4.0f} {:4.0f} {:4.0f} | Epsilon: {:.4f}'\n",
    "            print(template.format(self.episodes, format_time(time() - self.start),\n",
    "                                  avg_rewards_100, avg_rewards_10, max_rewards_10,\n",
    "                                  avg_steps_100, avg_steps_10, max_steps_10,\n",
    "                                  self.epsilon))\n",
    "\n",
    "    def memorize_transition(self, s, a, r, s_prime, done):\n",
    "        self.experience.store(s, a, r, s_prime, done)\n",
    "        self.episode_reward += r\n",
    "        self.episode_length += 1\n",
    "\n",
    "        if done:\n",
    "            self.epsilon_history.append(self.epsilon)\n",
    "            self.decay_epsilon()\n",
    "            self.episodes += 1\n",
    "            self.log_progress()\n",
    "            self.episode_reward = 0\n",
    "            self.episode_length = 0\n",
    "\n",
    "    def experience_replay(self):\n",
    "        # not enough experience yet\n",
    "        if self.batch_size > self.experience.idx:\n",
    "            return\n",
    "\n",
    "        # sample minibatch\n",
    "        states, actions, rewards, next_states, done = self.experience.sample(self.batch_size)\n",
    "\n",
    "        # select best next action (online)\n",
    "        next_action = tf.argmax(self.online_network.predict(next_states, self.batch_size), axis=1, name='next_action')\n",
    "        # predict next q values (target)\n",
    "        next_q_values = self.target_network.predict(next_states, self.batch_size)\n",
    "        # get q values for best next action\n",
    "        target_q = (tf.math.reduce_sum(next_q_values *\n",
    "                                       tf.one_hot(next_action,\n",
    "                                                  self.num_actions),\n",
    "                                       axis=1, name='target_q'))\n",
    "        # compute td target\n",
    "        td_target = rewards + done * self.gamma * target_q\n",
    "\n",
    "        with tf.GradientTape() as tape:\n",
    "            q_values = self.online_network(states)\n",
    "            q_values = tf.math.reduce_sum(q_values * tf.one_hot(actions, self.num_actions), axis=1, name='q_values')\n",
    "            loss = tf.math.reduce_mean(tf.square(td_target - q_values))\n",
    "\n",
    "        # run back propagation\n",
    "        variables = self.online_network.trainable_variables\n",
    "        gradients = tape.gradient(loss, variables)\n",
    "\n",
    "        self.optimizer.apply_gradients(zip(gradients, variables))\n",
    "        with self.summary_writer.as_default():\n",
    "            tf.summary.scalar('Loss', loss, step=self.train_steps)\n",
    "        self.train_steps += 1\n",
    "\n",
    "        if self.total_steps % self.tau == 0:\n",
    "            self.update_target()\n",
    "\n",
    "    def store_results(self):\n",
    "        result = pd.DataFrame({'Rewards': self.rewards_history,\n",
    "                               'Steps'  : self.steps_per_episode,\n",
    "                               'Epsilon': self.epsilon_history},\n",
    "                              index=list(range(1, len(self.rewards_history) + 1)))\n",
    "\n",
    "        result.to_csv(self.results_dir / 'results.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run Experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.172692Z",
     "start_time": "2020-06-22T16:35:25.159020Z"
    }
   },
   "outputs": [],
   "source": [
    "experiment = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.181103Z",
     "start_time": "2020-06-22T16:35:25.174404Z"
    }
   },
   "outputs": [],
   "source": [
    "results_dir = Path('results', 'lunar_lander', 'experiment_{}'.format(experiment))\n",
    "if not results_dir.exists():\n",
    "    results_dir.mkdir(parents=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set up OpenAI Gym Lunar Lander Environment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will begin by instantiating and extracting key parameters from the LL environment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.205360Z",
     "start_time": "2020-06-22T16:35:25.182218Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[42]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env = gym.make('LunarLander-v2')\n",
    "state_dim = env.observation_space.shape[0]  # number of dimensions in state\n",
    "num_actions = env.action_space.n  # number of actions\n",
    "max_episode_steps = env.spec.max_episode_steps  # max number of steps per episode\n",
    "env.seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also use the built-in wrappers that permit the periodic storing of videos that display the agent's performance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.208285Z",
     "start_time": "2020-06-22T16:35:25.206413Z"
    }
   },
   "outputs": [],
   "source": [
    "monitor_path = results_dir / 'monitor'\n",
    "video_freq = 500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.218448Z",
     "start_time": "2020-06-22T16:35:25.209619Z"
    }
   },
   "outputs": [],
   "source": [
    "env = wrappers.Monitor(env,\n",
    "                       directory=monitor_path.as_posix(),\n",
    "                       video_callable=lambda count: count % video_freq == 0,\n",
    "                      force=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define hyperparameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The agent's performance is quite sensitive to several hyperparameters. We will start with the discount before setting the Q-Network, replay buffer, and ε-greedy policy parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Discount Factor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.229754Z",
     "start_time": "2020-06-22T16:35:25.220699Z"
    }
   },
   "outputs": [],
   "source": [
    "gamma = .99"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q-Network Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.237291Z",
     "start_time": "2020-06-22T16:35:25.231093Z"
    }
   },
   "outputs": [],
   "source": [
    "learning_rate = 0.0001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.246639Z",
     "start_time": "2020-06-22T16:35:25.238491Z"
    }
   },
   "outputs": [],
   "source": [
    "architecture = (256, 256)  # units per layer\n",
    "l2_reg = 1e-6  # L2 regularization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will update the target network every 100 time steps, store up to 1 m past episodes in the replay memory, and sample mini-batches of 1,024 from memory to train the agent:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-04-12T19:00:19.808052Z",
     "start_time": "2020-04-12T19:00:19.801375Z"
    }
   },
   "source": [
    "### Replay Buffer Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.254353Z",
     "start_time": "2020-06-22T16:35:25.247863Z"
    }
   },
   "outputs": [],
   "source": [
    "tau = 100  # target network update frequency\n",
    "replay_capacity = int(1e6)\n",
    "batch_size = 1024"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ε-greedy Policy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ε-greedy policy starts with pure exploration at ε=1 and linearly decays every step to 0.01 over 100 episodes, followed by exponential decay at rate 0.99:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.262365Z",
     "start_time": "2020-06-22T16:35:25.255507Z"
    }
   },
   "outputs": [],
   "source": [
    "epsilon_start = 1.0\n",
    "epsilon_end = 0.01\n",
    "epsilon_decay_steps = 100\n",
    "epsilon_exponential_decay = .99"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instantiate DDQN Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.813848Z",
     "start_time": "2020-06-22T16:35:25.263500Z"
    }
   },
   "outputs": [],
   "source": [
    "agent = DDQNAgent(state_dim=state_dim,\n",
    "                  num_actions=num_actions,\n",
    "                  learning_rate=learning_rate,\n",
    "                  gamma=gamma,\n",
    "                  epsilon_start=epsilon_start,\n",
    "                  epsilon_end=epsilon_end,\n",
    "                  epsilon_decay_steps=epsilon_decay_steps,\n",
    "                  epsilon_exponential_decay=epsilon_exponential_decay,\n",
    "                  replay_capacity=replay_capacity,\n",
    "                  architecture=architecture,\n",
    "                  l2_reg=l2_reg,\n",
    "                  tau=tau,\n",
    "                  batch_size=batch_size,\n",
    "                  results_dir=results_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train & test agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.818722Z",
     "start_time": "2020-06-22T16:35:25.815089Z"
    }
   },
   "outputs": [],
   "source": [
    "tf.keras.backend.clear_session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T16:35:25.835561Z",
     "start_time": "2020-06-22T16:35:25.821372Z"
    }
   },
   "outputs": [],
   "source": [
    "max_episodes = 2500\n",
    "test_episodes = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besides the episode number an elapsed time, we log the moving averages for the last 100 and last 10 rewards and episode lengths, as well as their respective maximum values over the last 10 iterations. We also track the decay of epsilon. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T17:51:07.215382Z",
     "start_time": "2020-06-22T16:35:25.837388Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "010 | 00:00:05 | Rewards -193 -193  -70 | Steps:   93   93  143 | Epsilon: 0.9010\n",
      "020 | 00:00:44 | Rewards -166 -139  -59 | Steps:   99  105  178 | Epsilon: 0.8020\n",
      "030 | 00:01:29 | Rewards -157 -138   -6 | Steps:  104  112  140 | Epsilon: 0.7030\n",
      "040 | 00:02:26 | Rewards -137  -76   44 | Steps:  109  126  179 | Epsilon: 0.6040\n",
      "050 | 00:03:34 | Rewards -129  -96  -39 | Steps:  117  146  207 | Epsilon: 0.5050\n",
      "060 | 00:06:58 | Rewards -115  -46   27 | Steps:  169  430 1000 | Epsilon: 0.4060\n",
      "070 | 00:11:34 | Rewards -106  -53   26 | Steps:  224  555 1000 | Epsilon: 0.3070\n",
      "080 | 00:19:25 | Rewards -100  -57   55 | Steps:  309  906 1000 | Epsilon: 0.2080\n",
      "090 | 00:27:19 | Rewards  -76  113  225 | Steps:  371  866 1000 | Epsilon: 0.1090\n",
      "100 | 00:33:30 | Rewards  -50  185  283 | Steps:  404  702 1000 | Epsilon: 0.0100\n",
      "110 | 00:37:49 | Rewards  -15  155  263 | Steps:  451  558 1000 | Epsilon: 0.0090\n",
      "120 | 00:41:24 | Rewards   16  178  284 | Steps:  485  453 1000 | Epsilon: 0.0082\n",
      "130 | 00:44:08 | Rewards   35   44  262 | Steps:  509  349  672 | Epsilon: 0.0074\n",
      "140 | 00:48:48 | Rewards   51   91  261 | Steps:  554  577 1000 | Epsilon: 0.0067\n",
      "150 | 00:53:26 | Rewards   77  162  279 | Steps:  592  521  928 | Epsilon: 0.0061\n",
      "160 | 00:56:33 | Rewards  105  235  277 | Steps:  588  394  993 | Epsilon: 0.0055\n",
      "170 | 00:58:54 | Rewards  136  255  279 | Steps:  563  302  373 | Epsilon: 0.0049\n",
      "180 | 01:02:30 | Rewards  165  233  281 | Steps:  516  440 1000 | Epsilon: 0.0045\n",
      "190 | 01:06:30 | Rewards  176  226  268 | Steps:  475  449 1000 | Epsilon: 0.0040\n",
      "200 | 01:10:17 | Rewards  181  229  301 | Steps:  445  402 1000 | Epsilon: 0.0037\n",
      "210 | 01:12:56 | Rewards  190  249  283 | Steps:  419  306  534 | Epsilon: 0.0033\n",
      "220 | 01:15:12 | Rewards  198  259  286 | Steps:  400  264  304 | Epsilon: 0.0030\n"
     ]
    }
   ],
   "source": [
    "while agent.episodes < max_episodes:\n",
    "    this_state = env.reset()\n",
    "    done = False\n",
    "    while not done:\n",
    "        action = agent.epsilon_greedy_policy(this_state.reshape(-1, state_dim))\n",
    "        next_state, reward, done, _ = env.step(action)\n",
    "        agent.memorize_transition(this_state, action, reward, next_state, done)\n",
    "        agent.experience_replay()\n",
    "        this_state = next_state\n",
    "    if np.mean(agent.rewards_history[-100:]) > 200:\n",
    "        break\n",
    "\n",
    "agent.store_results()\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluate Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T17:51:07.221985Z",
     "start_time": "2020-06-22T17:51:07.216451Z"
    }
   },
   "outputs": [],
   "source": [
    "results = pd.read_csv(results_dir / 'results.csv')\n",
    "results['MA100'] = results.rolling(window=100, min_periods=25).Rewards.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T17:51:08.128220Z",
     "start_time": "2020-06-22T17:51:07.223256Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(ncols=2, figsize=(16, 4), sharex=True)\n",
    "results[['Rewards', 'MA100']].plot(ax=axes[0])\n",
    "axes[0].set_ylabel('Rewards')\n",
    "axes[0].set_xlabel('Episodes')\n",
    "axes[0].axhline(200, c='k', ls='--', lw=1)\n",
    "results[['Steps', 'Epsilon']].plot(secondary_y='Epsilon', ax=axes[1]);\n",
    "axes[1].set_xlabel('Episodes')\n",
    "fig.suptitle('Double Deep Q-Network Agent | Lunar Lander', fontsize=16)\n",
    "fig.tight_layout()\n",
    "fig.subplots_adjust(top=.9)\n",
    "fig.savefig(results_dir / 'trading_agent_2ed', dpi=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensorboard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T17:51:08.135938Z",
     "start_time": "2020-06-22T17:51:08.129396Z"
    }
   },
   "outputs": [],
   "source": [
    "%load_ext tensorboard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T18:02:33.859062Z",
     "start_time": "2020-06-22T18:02:31.825887Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "      <iframe id=\"tensorboard-frame-7f255c40ca82d62e\" width=\"100%\" height=\"800\" frameborder=\"0\">\n",
       "      </iframe>\n",
       "      <script>\n",
       "        (function() {\n",
       "          const frame = document.getElementById(\"tensorboard-frame-7f255c40ca82d62e\");\n",
       "          const url = new URL(\"/\", window.location);\n",
       "          url.port = 6011;\n",
       "          frame.src = url;\n",
       "        })();\n",
       "      </script>\n",
       "  "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%tensorboard --logdir results/lunar_lander/experiment_0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:ml4t-dl]",
   "language": "python",
   "name": "conda-env-ml4t-dl-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
